import pytest
from mistralai.mistral_jobs import MistralJobs

# --- Models and Utilities (minimal stubs for testing) ---

class APIEndpoint:
    def __init__(self, name):
        self.name = name

class BatchJobIn:
    def __init__(self, input_files, endpoint, model, agent_id, metadata, timeout_hours):
        self.input_files = input_files
        self.endpoint = endpoint
        self.model = model
        self.agent_id = agent_id
        self.metadata = metadata
        self.timeout_hours = timeout_hours

class BatchJobOut:
    def __init__(self, job_id, status, input_files, endpoint, model, agent_id, metadata, timeout_hours):
        self.job_id = job_id
        self.status = status
        self.input_files = input_files
        self.endpoint = endpoint
        self.model = model
        self.agent_id = agent_id
        self.metadata = metadata
        self.timeout_hours = timeout_hours

class SDKError(Exception):
    pass

UNSET = object()

# --- Fake HTTP client and response for testing ---

class FakeHttpResponse:
    def __init__(self, status_code, json_data, headers=None):
        self.status_code = status_code
        self._json_data = json_data
        self.headers = headers or {"content-type": "application/json"}
        self.text = str(json_data)
        self.url = "http://fake.url"

    def json(self):
        return self._json_data

class FakeHttpClient:
    def __init__(self, expected_response):
        self.expected_response = expected_response
        self.last_request = None

    def build_request(self, method, url, **kwargs):
        # Just store the request for inspection
        self.last_request = {
            "method": method,
            "url": url,
            "kwargs": kwargs,
        }
        # Return a dummy request object
        return self.last_request

    def send(self, req, stream=False):
        # Always return the expected response
        return self.expected_response

# --- SDK Configuration stub ---

class SDKConfiguration:
    def __init__(
        self,
        client,
        security=None,
        server_url="https://api.mistral.ai",
        retry_config=UNSET,
        timeout_ms=1000,
        user_agent="pytest-agent"
    ):
        self.client = client
        self.security = security
        self.server_url = server_url
        self.retry_config = retry_config
        self.timeout_ms = timeout_ms
        self.user_agent = user_agent
        self.debug_logger = self
        self._hooks = self
    # Logger stub
    def debug(self, *args, **kwargs):
        pass
    # Hooks stubs
    def before_request(self, ctx, req):
        return req
    def after_error(self, ctx, res, err):
        return (res, err)
    def after_success(self, ctx, res):
        return res
    def get_server_details(self):
        return self.server_url, {}

def serialize_request_body(request, *args, **kwargs):
    class SerializedRequestBody:
        def __init__(self):
            self.media_type = "application/json"
            self.content = str(request.__dict__).encode()
            self.data = None
            self.files = None
    return SerializedRequestBody()
from mistralai.mistral_jobs import MistralJobs

# --- Unit Tests ---

# Helper to build a fake job output dict
def build_job_output(input_files, endpoint, model, agent_id, metadata, timeout_hours):
    return {
        "job_id": "job123",
        "status": "queued",
        "input_files": input_files,
        "endpoint": endpoint,
        "model": model,
        "agent_id": agent_id,
        "metadata": metadata,
        "timeout_hours": timeout_hours,
    }

# ---------- BASIC TEST CASES ----------




def test_create_empty_input_files_raises():
    """Test that empty input_files raises ValueError."""
    endpoint = APIEndpoint("endpointD")
    sdk_config = SDKConfiguration(client=FakeHttpClient(None))
    jobs = MistralJobs(sdk_config)
    with pytest.raises(ValueError):
        jobs.create(input_files=[], endpoint=endpoint) # 48.6μs -> 38.1μs (27.7% faster)

def test_create_input_files_not_list_raises():
    """Test that non-list input_files raises ValueError."""
    endpoint = APIEndpoint("endpointE")
    sdk_config = SDKConfiguration(client=FakeHttpClient(None))
    jobs = MistralJobs(sdk_config)
    with pytest.raises(ValueError):
        jobs.create(input_files="notalist", endpoint=endpoint) # 35.1μs -> 27.3μs (28.7% faster)


def test_create_negative_timeout_hours_raises():
    """Test that negative timeout_hours raises ValueError."""
    endpoint = APIEndpoint("endpointF")
    sdk_config = SDKConfiguration(client=FakeHttpClient(None))
    jobs = MistralJobs(sdk_config)
    with pytest.raises(ValueError):
        jobs.create(input_files=["file.txt"], endpoint=endpoint, timeout_hours=-5) # 47.9μs -> 37.5μs (27.6% faster)

def test_create_zero_timeout_hours_raises():
    """Test that zero timeout_hours raises ValueError."""
    endpoint = APIEndpoint("endpointG")
    sdk_config = SDKConfiguration(client=FakeHttpClient(None))
    jobs = MistralJobs(sdk_config)
    with pytest.raises(ValueError):
        jobs.create(input_files=["file.txt"], endpoint=endpoint, timeout_hours=0) # 35.6μs -> 27.0μs (31.7% faster)

def test_create_nonint_timeout_hours_raises():
    """Test that non-integer timeout_hours raises ValueError."""
    endpoint = APIEndpoint("endpointH")
    sdk_config = SDKConfiguration(client=FakeHttpClient(None))
    jobs = MistralJobs(sdk_config)
    with pytest.raises(ValueError):
        jobs.create(input_files=["file.txt"], endpoint=endpoint, timeout_hours="not-an-int") # 34.1μs -> 26.4μs (29.1% faster)








#------------------------------------------------
from typing import Any, Dict, List, Mapping, Optional

# imports
import pytest
from mistralai.mistral_jobs import MistralJobs

# --- Minimal stubs for dependencies ---

# UNSET marker
class UnsetType:
    pass
UNSET = UnsetType()

# Models
class APIEndpoint:
    def __init__(self, name: str):
        self.name = name

class BatchJobIn:
    def __init__(self, input_files, endpoint, model, agent_id, metadata, timeout_hours):
        self.input_files = input_files
        self.endpoint = endpoint
        self.model = model
        self.agent_id = agent_id
        self.metadata = metadata
        self.timeout_hours = timeout_hours

class BatchJobOut:
    def __init__(self, job_id, status, input_files, endpoint, model, agent_id, metadata, timeout_hours):
        self.job_id = job_id
        self.status = status
        self.input_files = input_files
        self.endpoint = endpoint
        self.model = model
        self.agent_id = agent_id
        self.metadata = metadata
        self.timeout_hours = timeout_hours

class SDKError(Exception):
    pass

# SDKConfiguration stub
class SDKConfiguration:
    def __init__(self, client=None, security=None, retry_config=UNSET, timeout_ms=None, user_agent="test-agent"):
        self.client = client
        self.security = security
        self.retry_config = retry_config
        self.timeout_ms = timeout_ms
        self.user_agent = user_agent
        self.debug_logger = self
        self._hooks = self
    def get_server_details(self):
        return ("https://api.mistral.ai", {})
    def debug(self, *args, **kwargs):
        pass
    def before_request(self, ctx, req): return req
    def after_error(self, ctx, res, err): return (None, err)
    def after_success(self, ctx, res): return res

# HttpClient stub
class DummyHttpClient:
    def __init__(self, response_map):
        self.response_map = response_map
    def build_request(self, method, url, params, content, data, files, headers, timeout):
        # Just return a dummy request object
        return DummyRequest(method, url, params, content, data, files, headers, timeout)
    def send(self, req, stream=False):
        # Return a dummy response based on input
        key = (req.method, req.url)
        if key in self.response_map:
            return self.response_map[key]
        return DummyResponse(200, req.url, {}, '{"job_id":"default","status":"queued"}')

class DummyRequest:
    def __init__(self, method, url, params, content, data, files, headers, timeout):
        self.method = method
        self.url = url
        self.params = params
        self.content = content
        self.data = data
        self.files = files
        self.headers = headers
        self.timeout = timeout

class DummyResponse:
    def __init__(self, status_code, url, headers, text):
        self.status_code = status_code
        self.url = url
        self.headers = headers
        self.text = text
    def iter_text(self):
        yield self.text

# utils stubs
def serialize_request_body(request, a, b, c, typ):
    class Body:
        media_type = "application/json"
        content = '{"job_id":"abc","status":"queued"}'
        data = None
        files = None
    return Body()
from mistralai.mistral_jobs import MistralJobs

# --- Pytest unit tests ---

# Helper to build a jobs object with dummy http client
def make_jobs(response_map):
    sdk_config = SDKConfiguration(client=DummyHttpClient(response_map))
    return MistralJobs(sdk_config)

# Basic Test Cases


















#------------------------------------------------
from mistralai.mistral_jobs import MistralJobs